﻿using AutoMapper;
using Microsoft.AspNetCore.Routing;
using Serilog;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using WCS_Entity.AutoQeuipment;
using WCS_Entity.Dto.AutoEquipmentDto;
using WCS_Entity.Dto.RcsDto;
using WCS_Entity.Rcs;
using WCS_Repository.Interface;
using WCS_Repository.Repositories;
using WCS_Service.Interface;

namespace WCS_Service.Services
{
    /// <summary>
    /// RcsApi管理服务
    /// </summary>
    public class RcsApiService : BaseService<RcsApiEntity>, IRcsApiService
    {
        private readonly IRcsApiRepository _rcsApiRepository;
        private readonly IMapper _mapper;

        public RcsApiService(IRcsApiRepository rcsApiRepository,
                             IMapper mapper)
        {
            _rcsApiRepository = rcsApiRepository;
            _mapper = mapper;
        }
        public async Task<RcsApiDto> CreateRcsApiAsync(CreateRcsApiDto dto)
        {
            RcsApiDto result = new RcsApiDto();

            //var flag = await _rcsApiRepository.ExistsAsync(r => r.rcsId == dto.rcsId);
            //if (flag)
            //{
            //    Log.Error($"创建Rcs服务的Api设置失败");
            //    return null;
            //}
            var entity = _mapper.Map<RcsApiEntity>(dto);
            entity.createTime = DateTime.Now;
            await _rcsApiRepository.InsertAsync(entity);
            result = _mapper.Map<RcsApiDto>(entity);
            return result;
        }
        public async Task<bool> DeleteRcsApi(int id)
        {
            return await _rcsApiRepository.DeleteByIdAsync(id);
        }
        public async Task<List<RcsApiDto>> QueryAllRcsApiAsync()
        {
            List<RcsApiDto> result = new List<RcsApiDto>();
            Expression<Func<RcsApiEntity, object>> orderEx = p => p.createTime;
            var entityInfos = await _rcsApiRepository.QueryPageAsync(null, orderEx, OrderByType.Desc, 1, 10);
            if (entityInfos is null || !entityInfos.Any())
            {
                Log.Error("查询所有RcsApi失败");
                return null;
            }
            List<Task<RcsApiDto>> entityList = new List<Task<RcsApiDto>>();
            foreach (var item in entityInfos)
            {
                entityList.Add(GetDtoInfoAsync(item));
            }
            await Task.WhenAll(entityList);

            result = entityList.Select(e => e.Result).ToList();

            return result;
        }
        /// <summary>
        /// 根据RCSid查询所有api接口
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<List<RcsApiDto>> QueryRcsApiBaseRcsIdAsync(int id)
        {
            List<RcsApiDto> result = new List<RcsApiDto>();
            Expression<Func<RcsApiEntity, bool>> expression = eq => eq.rcsId == id;
            var entitys = await _rcsApiRepository.QueryListByClauseAsync(expression);
            if (entitys is null || !entitys.Any())
            {
                Log.Error($"查询rcs:{id}的API信息不存在");
                return null;
            }
            List<Task<RcsApiDto>> addInfos = new();
            foreach (var entity in entitys)
            {
                addInfos.Add(GetDtoInfoAsync(entity));
            }
            await Task.WhenAll(addInfos);
            result = addInfos.Select(e => e.Result).ToList();
            return result;
        }
        public async Task<RcsApiDto> QueryRcsApiAsync(int id)
        {
            RcsApiDto result = new RcsApiDto();
            var entityInfo = await _rcsApiRepository.QueryByIdAsync(id);
            if (entityInfo is null)
            {
                Log.Error($"查询指定RcsApi{id}不存在");
                return null;
            }
            result = _mapper.Map<RcsApiDto>(entityInfo);
            return result;
        }
        public async Task<RcsApiDto> UpdateRcsApiAsync(UpdateRcsApiDto dto)
        {
            RcsApiDto result = new RcsApiDto();
            var entityInfo = await _rcsApiRepository.QueryByIdAsync(dto.Id);
            if (entityInfo is null)
            {
                Log.Error($"编辑RcsApi{dto.Id}不存在");
                return null;
            }
            if (entityInfo.route != dto.route)
            {
                entityInfo.route = dto.route;
            }
            if (entityInfo.apiName != dto.apiName)
            {
                entityInfo.apiName = dto.apiName;
            }
            if (entityInfo.describe != dto.describe)
            {
                entityInfo.describe = dto.describe;
            }
            if (entityInfo.WCSDomainName != dto.WCSDomainName)
            {
                entityInfo.WCSDomainName = dto.WCSDomainName;
            }
            if (entityInfo.type != dto.type)
            {
                entityInfo.type = dto.type;
            }
            if (entityInfo.Extend1 != dto.Extend1)
            {
                entityInfo.Extend1 = dto.Extend1;
            }
            if (entityInfo.Extend2 != dto.Extend2)
            {
                entityInfo.Extend2 = dto.Extend2;
            }
            if (entityInfo.Extend3 != dto.Extend3)
            {
                entityInfo.Extend3 = dto.Extend3;
            }
            if (entityInfo.Extend4 != dto.Extend4)
            {
                entityInfo.Extend4 = dto.Extend4;
            }
            if (entityInfo.Extend5 != dto.Extend5)
            {
                entityInfo.Extend5 = dto.Extend5;
            }

            entityInfo.updataTime = DateTime.Now;
            result = _mapper.Map<RcsApiDto>(entityInfo);
            return result;
        }
        #region private
        private async Task<RcsApiDto> GetDtoInfoAsync(RcsApiEntity entity)
        {
            return await Task.Run(() => _mapper.Map<RcsApiDto>(entity));
        }
        #endregion
    }
}
